/**
 * 格式化工具函数集合
 * 提供统一的数据格式化方法
 */

/**
 * 将字节转换为人类可读的大小格式
 * @param {number|string} sizeInBytes - 字节大小
 * @returns {string} - 格式化后的大小字符串
 */
export const formatFileSize = (sizeInBytes) => {
  const bytes = Number(sizeInBytes);
  if (!bytes || isNaN(bytes) || bytes <= 0) return '0 B';

  // 转换单位：字节 -> KB -> MB -> GB -> TB
  if (bytes >= 1024 * 1024 * 1024 * 1024) {
    return `${(bytes / (1024 * 1024 * 1024 * 1024)).toFixed(1)} TB`;
  } else if (bytes >= 1024 * 1024 * 1024) {
    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
  } else if (bytes >= 1024 * 1024) {
    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
  } else if (bytes >= 1024) {
    return `${(bytes / 1024).toFixed(1)} KB`;
  } else {
    return `${bytes} B`;
  }
};

/**
 * 格式化时间为相对时间显示
 * @param {string} timeString - 时间字符串
 * @returns {string} - 格式化后的相对时间
 */
export const formatRelativeTime = (timeString) => {
  if (!timeString) return '未知时间';

  try {
    const date = new Date(timeString);

    // 检查日期是否有效
    if (isNaN(date.getTime())) {
      return '时间格式错误';
    }

    const now = new Date();
    const diffMs = now.getTime() - date.getTime();
    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
    const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
    const diffMinutes = Math.floor(diffMs / (1000 * 60));

    // 相对时间显示
    if (diffMinutes < 60) {
      return diffMinutes <= 0 ? '刚刚' : `${diffMinutes}分钟前`;
    } else if (diffHours < 24) {
      return `${diffHours}小时前`;
    } else if (diffDays < 7) {
      return `${diffDays}天前`;
    } else if (diffDays < 30) {
      const weeks = Math.floor(diffDays / 7);
      return `${weeks}周前`;
    } else if (diffDays < 365) {
      const months = Math.floor(diffDays / 30);
      return `${months}个月前`;
    } else {
      const years = Math.floor(diffDays / 365);
      return `${years}年前`;
    }
  } catch (error) {
    console.warn('时间格式化失败:', timeString, error);
    return '时间解析失败';
  }
};

/**
 * 格式化时间为完整的中文日期时间
 * @param {string} timeString - 时间字符串
 * @returns {string} - 格式化后的完整时间
 */
export const formatFullDateTime = (timeString) => {
  if (!timeString) return '未知时间';

  try {
    const date = new Date(timeString);

    if (isNaN(date.getTime())) {
      return '时间格式错误';
    }

    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');

    return `${year}年${month}月${day}日 ${hours}:${minutes}`;
  } catch (error) {
    console.warn('完整时间格式化失败:', timeString, error);
    return '时间解析失败';
  }
};

/**
 * 格式化时间为标准日期时间（用于系统显示）
 * @param {string} timeString - 时间字符串
 * @returns {string} - 格式化后的标准时间
 */
export const formatStandardDateTime = (timeString) => {
  if (!timeString) return '未知时间';

  try {
    return new Date(timeString).toLocaleString('zh-CN');
  } catch (error) {
    console.warn('标准时间格式化失败:', timeString, error);
    return '未知时间';
  }
};

/**
 * 将文件大小字符串解析为字节数
 * @param {string} sizeStr - 大小字符串如 "1.5 GB", "500 MB"
 * @returns {number} - 字节数
 */
export const parseFileSize = (sizeStr) => {
  if (!sizeStr || typeof sizeStr === 'number') return sizeStr || 0;

  const match = sizeStr.match(/(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)/i);
  if (!match) return 0;

  const size = parseFloat(match[1]);
  const unit = match[2].toUpperCase();

  switch (unit) {
    case 'TB':
      return size * 1024 * 1024 * 1024 * 1024;
    case 'GB':
      return size * 1024 * 1024 * 1024;
    case 'MB':
      return size * 1024 * 1024;
    case 'KB':
      return size * 1024;
    case 'B':
    default:
      return size;
  }
};

export default {
  formatFileSize,
  formatRelativeTime,
  formatFullDateTime,
  formatStandardDateTime,
  parseFileSize
}; 